import { defineStore } from 'pinia'
import { ref, computed } from 'vue'
import { authApi } from '@/api'
import type { User, LoginRequest } from '@/types'
import { ElMessage } from 'element-plus'

export const useAuthStore = defineStore('auth', () => {
  // 状态
  const token = ref<string>(localStorage.getItem('token') || '')
  const user = ref<User | null>(null)
  const loading = ref(false)

  // 计算属性
  const isLoggedIn = computed(() => !!token.value)

  const userRole = computed(() => {
    if (!user.value?.permissions) {
      return '用户'
    }
    const permissions = user.value.permissions
    const isManager = permissions.includes('客户档案') && permissions.includes('宠物档案')
    const hasServicePermission = permissions.some(p => p.includes('服务'))

    if (isManager) {
      return '管理员'
    }
    if (hasServicePermission) {
      return '员工'
    }
    return '用户'
  })

  // 添加编辑和删除权限的计算属性
  const canEdit = computed(() => {
    return userRole.value === '管理员' || userRole.value === '员工'
  })

  const canDelete = computed(() => {
    return userRole.value === '管理员' || userRole.value === '员工'
  })

  // 新增基于权限列表的检查方法
  const hasPermission = (permissionKey: string): boolean => {
    if (!user.value || !user.value.permissions) {
      return false
    }
    return user.value.permissions.includes(permissionKey)
  }

  // 登录
  const login = async (loginData: LoginRequest) => {
    try {
      loading.value = true
      console.log('开始登录，用户名:', loginData.username)
      
      // 真实API调用
      const response = await authApi.login(loginData)
      console.log('登录API响应:', response)
      console.log('登录API响应数据结构:', JSON.stringify(response, null, 2))
      
      if (response.code === 200) {
        // 处理不同的数据结构
        let localToken = null
        let localUser = null
        let functionList = []
        
        // 直接从响应中提取功能列表
        if (response.data && Array.isArray(response.data)) {
          functionList = response.data
          console.log('从response.data数组中提取功能列表:', functionList)
        }
        
        if (response.data && typeof response.data === 'object') {
          console.log('处理登录响应数据:', response.data)
          
          // 直接从 response.data 中提取 token 和 user 信息
          if (response.data.token) {
            localToken = response.data.token
            console.log('从response.data中提取token:', localToken)
          }
          
          // 如果 response.data 本身就包含用户信息，直接使用它
          if (response.data.username || response.data.userId || response.data.name) {
            localUser = response.data
            console.log('直接从 response.data 提取的用户信息:', localUser)
          } else if (response.data.user) {
            // 如果有嵌套的 user 对象，使用它
            localUser = response.data.user
            console.log('从 response.data.user 提取的用户信息:', localUser)
          }
          
          // 提取功能列表
          if (Array.isArray(response.data)) {
            functionList = response.data
            console.log('从 response.data 数组提取的功能列表:', functionList)
          } else if (response.data.data && Array.isArray(response.data.data)) {
            functionList = response.data.data
            console.log('从 response.data.data 数组提取的功能列表:', functionList)
          } else if (Array.isArray(response.data.permissions)) {
            functionList = response.data.permissions
            console.log('从 response.data.permissions 提取的功能列表:', functionList)
          } else if (Array.isArray(response.data.functions)) {
            functionList = response.data.functions
            console.log('从 response.data.functions 提取的功能列表:', functionList)
          } else if (Array.isArray(response.data.menus)) {
            functionList = response.data.menus
            console.log('从 response.data.menus 提取的功能列表:', functionList)
          } else if (response.data.user && Array.isArray(response.data.user.permissions)) {
            functionList = response.data.user.permissions
            console.log('从 response.data.user.permissions 提取的功能列表:', functionList)
          }
        }
        
        // 如果没有token，生成一个临时token
        if (!localToken) {
          localToken = `temp-token-${Date.now()}`
          console.log('未找到token，生成临时token:', localToken)
        }
        
        // 如果还是没有user，创建一个基本的用户对象
        if (!localUser) {
          localUser = {
            userId: 1,
            username: loginData.username,
            name: loginData.username
          }
          console.log('未找到user信息，创建默认用户对象:', localUser)
        }
        
        // 将功能列表保存到用户对象中
        localUser.permissions = functionList
        console.log('最终保存的功能列表:', localUser.permissions)
        
        token.value = localToken
        user.value = localUser
        
        // 保存到本地存储
        localStorage.setItem('token', localToken)
        localStorage.setItem('user', JSON.stringify(localUser))
        
        console.log('登录成功，token:', localToken)
        console.log('登录成功，user:', localUser)
        
        ElMessage.success('登录成功')
        return true
      } else {
        console.log('登录失败，错误信息:', response.message || response.msg)
        ElMessage.error(response.message || response.msg || '登录失败')
        return false
      }
    } catch (error) {
      console.error('登录失败:', error)
      ElMessage.error('登录失败，请检查网络连接')
      return false
    } finally {
      loading.value = false
    }
  }

  // 获取当前用户信息
  const getCurrentUser = async () => {
    if (!token.value) return false
    
    try {
      // 真实API调用
      const response = await authApi.getCurrentUser()
      if (response.code === 200) {
        user.value = response.data
        localStorage.setItem('user', JSON.stringify(response.data))
        return true
      } else {
        // token可能已过期
        logout()
        return false
      }
    } catch (error) {
      console.error('获取用户信息失败:', error)
      logout()
      return false
    }
  }

  // 登出
  const logout = () => {
    token.value = ''
    user.value = null
    localStorage.removeItem('token')
    localStorage.removeItem('user')
    ElMessage.success('已退出登录')
  }

  // 初始化 - 从本地存储恢复状态
  const init = () => {
    const savedToken = localStorage.getItem('token')
    const savedUser = localStorage.getItem('user')
    
    if (savedToken) {
      token.value = savedToken
    }
    
    if (savedUser && savedUser !== 'undefined') {
      try {
        user.value = JSON.parse(savedUser)
      } catch (error) {
        console.error('解析用户信息失败:', error)
        localStorage.removeItem('user')
        user.value = null
      }
    } else {
      user.value = null
    }
  }

  // 权限检查方法 (这个可以保留用于简单的UI控制，但核心菜单权限将使用新的 hasPermission)
  const canPerformAction = (action: 'read' | 'write' | 'delete' | 'add') => {
    if (!isLoggedIn.value) return false
    
    // 示例：可以根据更细粒度的后端权限来判断
    // 这里我们暂时保留一个简单的逻辑：认为有超过一个权限点的就是管理员
    if (user.value?.permissions && user.value.permissions.length > 1) {
        return true
    }
    
    // 普通用户只有读权限
    return action === 'read'
  }

  return {
    // 状态
    token,
    user,
    loading,
    
    // 计算属性
    isLoggedIn,
    userRole,
    canEdit,
    canDelete,
    
    // 方法
    login,
    logout,
    getCurrentUser,
    init,
    hasPermission, // 导出新的权限检查方法
    canPerformAction,
  }
}) 